// Base64Decoder.java
// $Id: Base64Decoder.java,v 1.6 2000/08/16 21:37:48 ylafon Exp $
// (c) COPYRIGHT MIT and INRIA, 1996.
// Please first read the full copyright statement in file COPYRIGHT.html
package sfsumapserver;

import java.io.*;

/**
 * Decode a BASE64 encoded input stream to some output stream. This class
 * implements BASE64 decoding, as specified in the <a
 * href="http://ds.internic.net/rfc/rfc1521.txt">MIME specification</a>.
 * 
 * @see org.w3c.tools.codec.Base64Encoder
 */
public class Base64Decoder {

	private static final int BUFFER_SIZE = 1024;
	InputStream in = null;
	OutputStream out = null;
	boolean stringp = false;

	private void printHex(int x) {
		int h = (x & 0xf0) >> 4;
		int l = (x & 0x0f);
		System.out.print((new Character((char) ((h > 9) ? 'A' + h - 10
				: '0' + h))).toString()
				+ (new Character((char) ((l > 9) ? 'A' + l - 10 : '0' + l)))
						.toString());
	}

	private void printHex(byte buf[], int off, int len) {
		while (off < len) {
			printHex(buf[off++]);
			System.out.print(" ");
		}
		System.out.println("");
	}

	private void printHex(String s) {
		byte bytes[];
		try {
			bytes = s.getBytes("ISO-8859-1");
		} catch (UnsupportedEncodingException ex) {
			throw new RuntimeException(this.getClass().getName()
					+ "[printHex] Unable to convert" + "properly char to bytes");
		}
		printHex(bytes, 0, bytes.length);
	}

	private final int get1(byte buf[], int off) {
		return ((buf[off] & 0x3f) << 2) | ((buf[off + 1] & 0x30) >>> 4);
	}

	private final int get2(byte buf[], int off) {
		return ((buf[off + 1] & 0x0f) << 4) | ((buf[off + 2] & 0x3c) >>> 2);
	}

	private final int get3(byte buf[], int off) {
		return ((buf[off + 2] & 0x03) << 6) | (buf[off + 3] & 0x3f);
	}

	private final int check(int ch) {
		if ((ch >= 'A') && (ch <= 'Z')) {
			return ch - 'A';
		} else if ((ch >= 'a') && (ch <= 'z')) {
			return ch - 'a' + 26;
		} else if ((ch >= '0') && (ch <= '9')) {
			return ch - '0' + 52;
		} else {
			switch (ch) {
			case '=':
				return 65;
			case '+':
				return 62;
			case '/':
				return 63;
			default:
				return -1;
			}
		}
	}

	/**
	 * Do the actual decoding. Process the input stream by decoding it and
	 * emiting the resulting bytes into the output stream.
	 * 
	 * @exception IOException
	 *                If the input or output stream accesses failed.
	 * @exception Base64FormatException
	 *                If the input stream is not compliant with the BASE64
	 *                specification.
	 */
	public void process() throws IOException, Base64FormatException {
		byte buffer[] = new byte[BUFFER_SIZE];
		byte chunk[] = new byte[4];
		int got = -1;
		int ready = 0;

		fill: while ((got = in.read(buffer)) > 0) {
			int skiped = 0;
			while (skiped < got) {
				// Check for un-understood characters:
				while (ready < 4) {
					if (skiped >= got) {
						continue fill;
					}
					int ch = check(buffer[skiped++]);
					if (ch >= 0) {
						chunk[ready++] = (byte) ch;
					}
				}
				if (chunk[2] == 65) {
					out.write(get1(chunk, 0));
					return;
				} else if (chunk[3] == 65) {
					out.write(get1(chunk, 0));
					out.write(get2(chunk, 0));
					return;
				} else {
					out.write(get1(chunk, 0));
					out.write(get2(chunk, 0));
					out.write(get3(chunk, 0));
				}
				ready = 0;
			}
		}
		if (ready != 0) {
			throw new Base64FormatException("Invalid length.");
		}
		out.flush();
	}

	/**
	 * Do the decoding, and return a String. This methods should be called when
	 * the decoder is used in <em>String</em> mode. It decodes the input string
	 * to an output string that is returned.
	 * 
	 * @exception RuntimeException
	 *                If the object wasn't constructed to decode a String.
	 * @exception Base64FormatException
	 *                If the input string is not compliant with the BASE64
	 *                specification.
	 */
	public String processString() throws Base64FormatException {
		if (!stringp) {
			throw new RuntimeException(this.getClass().getName()
					+ "[processString]" + "invalid call (not a String)");
		}
		try {
			process();
		} catch (IOException e) {
		}
		String s;
		try {
			s = ((ByteArrayOutputStream) out).toString("ISO-8859-1");
		} catch (UnsupportedEncodingException ex) {
			throw new RuntimeException(this.getClass().getName()
					+ "[processString] Unable to convert"
					+ "properly char to bytes");
		}
		return s;
	}

	/**
	 * Create a decoder to decode a String.
	 * 
	 * @param input
	 *            The string to be decoded.
	 */
	public Base64Decoder(String input) {
		byte bytes[];
		try {
			bytes = input.getBytes("ISO-8859-1");
		} catch (UnsupportedEncodingException ex) {
			throw new RuntimeException(this.getClass().getName()
					+ "[Constructor] Unable to convert"
					+ "properly char to bytes");
		}
		this.stringp = true;
		this.in = new ByteArrayInputStream(bytes);
		this.out = new ByteArrayOutputStream();
	}

	/**
	 * Create a decoder to decode a stream.
	 * 
	 * @param in
	 *            The input stream (to be decoded).
	 * @param out
	 *            The output stream, to write decoded data to.
	 */
	public Base64Decoder(InputStream in, OutputStream out) {
		this.in = in;
		this.out = out;
		this.stringp = false;
	}

	/**
	 * Test the decoder. Run it with one argument: the string to be decoded, it
	 * will print out the decoded value.
	 */
	public static void main(String args[]) {
		if (args.length == 1) {
			try {
				Base64Decoder b = new Base64Decoder(args[0]);
				System.out.println("[" + b.processString() + "]");
			} catch (Base64FormatException e) {
				System.out.println("Invalid Base64 format !");
				System.exit(1);
			}
		} else if ((args.length == 2) && (args[0].equals("-f"))) {
			try {
				FileInputStream in = new FileInputStream(args[1]);
				Base64Decoder b = new Base64Decoder(in, System.out);
				b.process();
			} catch (Exception ex) {
				System.out.println("error: " + ex.getMessage());
				System.exit(1);
			}
		} else {
			System.out.println("Base64Decoder [strong] [-f file]");
		}
		System.exit(0);
	}
}
